Go 实现简单的客户端服务器（CS）模式

如何实现一个简单的服务端客户端模式呢？

这里屏蔽了 Socket 连接细节，使用 Go 的服务器通常会在协程中执行向客户端的响应，故而会对每一个客户端请求启动一个协程。

一个常用的操作方法是客户端请求自身中包含一个通道，而服务器则向这个通道发送响应。

如下，一个基本的 C/S 架构设计

package main

import "fmt"

// 一个 Request 携带了基本的请求 a, b 以及用于回复客户端的 reply 管道
type Request struct {
    a, b   int
    replyc chan int // reply channel inside the Request
}

type binOp func(a, b int) int

func run(op binOp, req *Request) {
    req.replyc <- op(req.a, req.b)
}

func server(op binOp, service chan *Request, quit chan bool) {
    for {
        select {
        case req := <-service:
            go run(op, req)
        case <-quit:
            return
        }
    }
}

func startServer(op binOp) (service chan *Request, quit chan bool) {
    service = make(chan *Request)
    quit = make(chan bool)
    go server(op, service, quit)
    return service, quit
}

func main() {
    adder, quit := startServer(func(a, b int) int { return a + b })
    const N = 100
    var reqs [N]Request

    // 构建 100 个请求
    for i := 0; i < N; i++ {
        req := &reqs[i]
        req.a = i
        req.b = i + N
        req.replyc = make(chan int)

        // 把请求发送给 server
        adder <- req
    }

    // checks:
    for i := N - 1; i >= 0; i-- { // doesn't matter what order
        if <-reqs[i].replyc != N+2*i {
            fmt.Println("fail at", i)
        } else {
            fmt.Println("Request ", i, " is ok!")
        }
    }

    quit <- true
    fmt.Println("done")
}

限制同时处理的请求数

只需简单的修改：

// ...

const MAXREQS = 50

var sem = make(chan int, MAXREQS)

// ...

func process(op binOp, req *Request) int {
    return op(req.a, req.b)
}

func handle(op binOp, r *Request) {
    sem <- 1 // doesn't matter what we put in it
    result := process(op, r)
    <-sem // one empty place in the buffer: the next request can start
    r.replyc <- result
}

func server(op binOp, service chan *Request, quit chan bool) {
    for {
        select {
        case req := <-service:
            go handle(op, req)
        case <-quit:
            return
        }
    }
}

// ...

超过 MAXREQS 的请求将不会被同时处理，因为当信号通道表示缓冲区已满时 handle 函数会阻塞且不再处理其他请求，直到某个请求从 sem 中被移除。

但是注意！！ handle 方法一定要让 r.replyc <- result 放在下面，否则会造成信道死锁

References

Go语言学习——channel的死锁其实没那么复杂 14.10.1 典型的客户端/服务器（C/S）模式 14.11 限制同时处理的请求数